package com.mall.module.product.service.Impl;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mall.common.result.Result;
import com.mall.common.util.JsonUtils;
import com.mall.common.util.SecurityUtils;
import com.mall.module.product.domain.dto.*;
import com.mall.module.product.domain.entity.ProductRelation;
import com.mall.module.product.domain.entity.ProductSku;
import com.mall.module.product.domain.entity.ProductSpu;
import com.mall.module.product.domain.vo.NewProductVO;
import com.mall.module.product.domain.vo.ProductSpuDetailVO;
import com.mall.module.product.domain.vo.ProductSpuVO;
import com.mall.module.product.domain.vo.TagVO;
import com.mall.module.product.mapper.ProductRelationMapper;
import com.mall.module.product.mapper.ProductSkuMapper;
import com.mall.module.product.mapper.ProductSpuMapper;
import com.mall.module.product.service.ProductSpuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 商品SPU服务实现类
 */
@Slf4j
@Service
public class ProductSpuServiceImpl implements ProductSpuService {

    // 常量统一管理
    private static final Integer RELATION_TYPE_TAG = 1;
    private static final Integer RELATION_TYPE_PROMOTION = 2;
    private static final Integer DEFAULT_STATUS = 1;
    private static final Integer DEFAULT_SALES_COUNT = 0;
    private static final Integer DEFAULT_COMMENT_COUNT = 0;
    private static final Integer DEFAULT_STOCK_WARNING = 10;
    private static final String EMPTY_JSON_OBJECT = "{}";
    private static final Integer WARNING_TRIGGERED = 1;
    private static final Integer WARNING_NOT_TRIGGERED = 0;

    private final ProductSpuMapper productSpuMapper;
    private final ProductSkuMapper productSkuMapper;
    private final ProductRelationMapper productRelationMapper;
    private final ObjectMapper objectMapper;

    public ProductSpuServiceImpl(ProductSpuMapper productSpuMapper,
                                 ProductSkuMapper productSkuMapper,
                                 ProductRelationMapper productRelationMapper,
                                 ObjectMapper objectMapper) {
        this.productSpuMapper = productSpuMapper;
        this.productSkuMapper = productSkuMapper;
        this.productRelationMapper = productRelationMapper;
        this.objectMapper = objectMapper;
    }

    /**
     * 新增商品(包含SPU和SKU)
     *
     * @param dto 商品创建DTO
     * @return 新增商品的ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long save(ProductCreateDTO dto) {
        // 参数校验
        if (dto == null) {
            throw new IllegalArgumentException("商品创建数据不能为空");
        }
        
        if (dto.getSpuInfo() == null) {
            throw new IllegalArgumentException("商品SPU信息不能为空");
        }
        
        if (CollectionUtils.isEmpty(dto.getSkuList())) {
            throw new IllegalArgumentException("商品SKU列表不能为空");
        }
        
        // 1. 保存SPU信息
        ProductSpu spu = new ProductSpu();
        ProductSpuDTO spuDTO = dto.getSpuInfo();
        BeanUtils.copyProperties(spuDTO, spu);
        
        // 设置默认值
        spu.setSalesCount(DEFAULT_SALES_COUNT);
        spu.setCommentCount(DEFAULT_COMMENT_COUNT);
        
        // 验证分类ID是否存在
        if (spu.getCategoryId() != null) {
            // 这里应该调用分类服务检查分类是否存在
            // 如果分类服务不可用，可以直接查询数据库
            Integer categoryCount = productSpuMapper.checkCategoryExists(spu.getCategoryId());
            if (categoryCount == null || categoryCount == 0) {
                throw new IllegalArgumentException("指定的商品分类不存在");
            }
        }
        
        // 处理JSON字段
        try {
            if (spuDTO.getAlbumImages() != null) {
                spu.setAlbumImages(objectMapper.writeValueAsString(spuDTO.getAlbumImages()));
            }
        } catch (JsonProcessingException e) {
            log.error("处理商品图册JSON失败", e);
            spu.setAlbumImages("[]");
        }
        
        // 设置创建者信息
        if (dto.getCreateUser() != null) {
            spu.setCreatorId(dto.getCreateUser());
        } else {
            Long currentUserId = SecurityUtils.getCurrentUserId();
            spu.setCreatorId(currentUserId);
        }
        
        if (dto.getCreateTime() != null) {
            spu.setCreateTime(dto.getCreateTime());
        }
        
        // 插入SPU记录
        productSpuMapper.insert(spu);
        Long spuId = spu.getId();
        
        // 2. 保存SKU信息
        List<ProductSku> skuList = new ArrayList<>();
        
        // 校验SKU编码唯一性
        List<String> skuCodes = dto.getSkuList().stream()
                .map(ProductSkuDTO::getSkuCode)
                .filter(StringUtils::hasText)
                .collect(Collectors.toList());
                
        if (skuCodes.size() > 0) {
            // 检查是否有重复的SKU编码
            long distinctCount = skuCodes.stream().distinct().count();
            if (distinctCount != skuCodes.size()) {
                throw new IllegalArgumentException("SKU编码不能重复");
            }
            
            // 检查数据库中是否已存在相同的SKU编码
            List<String> existingCodes = productSkuMapper.checkSkuCodesExist(skuCodes);
            if (!existingCodes.isEmpty()) {
                throw new IllegalArgumentException("SKU编码已存在: " + String.join(", ", existingCodes));
            }
        }
        
        for (ProductSkuDTO skuDTO : dto.getSkuList()) {
            ProductSku sku = new ProductSku();
            BeanUtils.copyProperties(skuDTO, sku);
            
            // 库存校验
            if (sku.getStock() == null) {
                sku.setStock(0);
            } else if (sku.getStock() < 0) {
                throw new IllegalArgumentException("SKU库存不能为负数: " + sku.getName());
            }
            
            // 设置SKU ID和分类ID
            sku.setSpuId(spuId);
            sku.setCategoryId(spu.getCategoryId());
            
            // 生成SKU编码(如果未提供)
            if (!StringUtils.hasText(sku.getSkuCode())) {
                // 简单实现，实际可能需要更复杂的生成逻辑
                sku.setSkuCode("SKU" + System.currentTimeMillis() + "-" + skuList.size());
            }
            
            // 处理JSON字段
            try {
                if (skuDTO.getImages() != null) {
                    sku.setImages(objectMapper.writeValueAsString(skuDTO.getImages()));
                }
                
                if (skuDTO.getSpecData() != null) {
                    sku.setSpecData(objectMapper.writeValueAsString(skuDTO.getSpecData()));
                }
                
                if (skuDTO.getPresellConfig() != null) {
                    sku.setPresellConfig(objectMapper.writeValueAsString(skuDTO.getPresellConfig()));
                }
            } catch (JsonProcessingException e) {
                log.error("处理SKU JSON字段失败", e);
            }
            
            // 设置库存预警状态
            if (sku.getStock() <= sku.getStockWarning()) {
                sku.setIsWarning(WARNING_TRIGGERED);
            } else {
                sku.setIsWarning(WARNING_NOT_TRIGGERED);
            }
            
            // 设置创建者信息
            if (dto.getCreateUser() != null) {
                sku.setCreatorId(dto.getCreateUser());
            } else {
                Long currentUserId = SecurityUtils.getCurrentUserId();
                sku.setCreatorId(currentUserId);
            }
            
            if (dto.getCreateTime() != null) {
                sku.setCreateTime(dto.getCreateTime());
            }
            
            // 设置默认状态
            if (sku.getStatus() == null) {
                sku.setStatus(DEFAULT_STATUS);
            }
            
            skuList.add(sku);
        }
        
        // 批量插入SKU
        if (!skuList.isEmpty()) {
            productSkuMapper.batchInsert(skuList);
        }
        
        // 3. 处理商品与标签关联
        if (dto.getMarketingInfo() != null && !CollectionUtils.isEmpty(dto.getMarketingInfo().getTagIds())) {
            for (Long tagId : dto.getMarketingInfo().getTagIds()) {
                ProductRelation relation = new ProductRelation();
                relation.setProductId(spuId);
                relation.setRelationType(RELATION_TYPE_TAG);
                relation.setRefId(tagId);
                productRelationMapper.insert(relation);
            }
        }
        
        // 4. 处理商品与促销关联
        if (dto.getMarketingInfo() != null && !CollectionUtils.isEmpty(dto.getMarketingInfo().getPromotionIds())) {
            for (Long promotionId : dto.getMarketingInfo().getPromotionIds()) {
                ProductRelation relation = new ProductRelation();
                relation.setProductId(spuId);
                relation.setRelationType(RELATION_TYPE_PROMOTION);
                relation.setRefId(promotionId);
                productRelationMapper.insert(relation);
            }
        }
        
        return spuId;
    }

    /**
     * 更新商品SPU信息
     *
     * @param dto 商品SPU DTO
     */
    @Override
    public void update(ProductSpuDTO dto) {
        // 实现更新商品的逻辑
    }
    
    /**
     * 获取商品详情
     *
     * @param id 商品ID
     * @return 商品详情VO
     */
    @Override
    public ProductSpuDetailVO getDetail(Long id) {
        // 实现获取商品详情的逻辑
        return null;
    }
    
    /**
     * 删除商品
     *
     * @param id 商品ID
     * @param operatorId 操作人ID
     */
    @Override
    public void delete(Long id, Long operatorId) {
        // 实现删除商品的逻辑
    }
    
    /**
     * 分页查询商品列表
     *
     * @param queryDTO 查询条件
     * @return 商品列表
     */
    @Override
    public List<ProductSpuVO> page(ProductSpuPageQueryDTO queryDTO) {
        // 实现分页查询商品列表的逻辑
        return Collections.emptyList();
    }
    
    /**
     * 查询商品列表
     *
     * @param condition 查询条件
     * @return 商品列表
     */
    @Override
    public List<ProductSpuVO> list(ProductSpu condition) {
        // 实现查询商品列表的逻辑
        return Collections.emptyList();
    }
    
    /**
     * 根据分类ID查询商品列表
     *
     * @param categoryId 分类ID
     * @return 商品列表
     */
    @Override
    public List<ProductSpuVO> listByCategory(Long categoryId) {
        // 实现根据分类ID查询商品列表的逻辑
        return Collections.emptyList();
    }
    
    /**
     * 根据品牌ID查询商品列表
     *
     * @param brandId 品牌ID
     * @return 商品列表
     */
    @Override
    public List<ProductSpuVO> listByBrand(Long brandId) {
        // 实现根据品牌ID查询商品列表的逻辑
        return Collections.emptyList();
    }
    
    /**
     * 更新商品状态
     *
     * @param id 商品ID
     * @param status 状态
     */
    @Override
    public void updateStatus(Long id, Integer status) {
        // 实现更新商品状态的逻辑
    }
    
    /**
     * 批量操作商品
     *
     * @param operationDTO 批量操作DTO
     */
    @Override
    public void batchOperation(BatchOperationDTO operationDTO) {
        // 实现批量操作商品的逻辑
    }
    
    /**
     * 添加商品标签关联
     *
     * @param productId 商品ID
     * @param tagIds 标签ID列表
     */
    @Override
    public void addProductTags(Long productId, List<Long> tagIds) {
        // 实现添加商品标签关联的逻辑
    }
    
    /**
     * 移除商品标签关联
     *
     * @param productId 商品ID
     * @param tagIds 标签ID列表
     */
    @Override
    public void removeProductTags(Long productId, List<Long> tagIds) {
        // 实现移除商品标签关联的逻辑
    }
    
    /**
     * 添加商品促销关联
     *
     * @param productId 商品ID
     * @param promotionIds 促销ID列表
     */
    @Override
    public void addProductPromotions(Long productId, List<Long> promotionIds) {
        // 实现添加商品促销关联的逻辑
    }
    
    /**
     * 移除商品促销关联
     *
     * @param productId 商品ID
     * @param promotionIds 促销ID列表
     */
    @Override
    public void removeProductPromotions(Long productId, List<Long> promotionIds) {
        // 实现移除商品促销关联的逻辑
    }
    
    /**
     * 获取新品列表
     *
     * @param pageNum 页码
     * @param pageSize 每页数量
     * @return 新品列表
     */
    @Override
    public List<NewProductVO> listNewProduct(Integer pageNum, Integer pageSize) {
        // 实现获取新品列表的逻辑
        return Collections.emptyList();
    }
}
